package com.example.apitesttool.controller;

import com.example.apitesttool.service.AiChatService;
import dev.ai4j.openai4j.OpenAiHttpException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.Map;

/**
 * AI 聊天控制器
 * <p>
 * 提供对话式接口测试的 REST API 接口。
 * 用户可以通过自然语言与 AI 交互，执行接口测试任务。
 * <p>
 * 主要功能：
 * - 处理用户的聊天消息
 * - 返回 AI 的智能响应
 * - 提供服务状态查询
 * - 错误处理和用户友好的响应
 *
 * @author liuxy
 * @version 1.0.0
 */
@RestController
@RequestMapping("/api/chat")
@CrossOrigin(origins = "*") // 允许跨域请求
public class ChatController {

    private static final Logger logger = LoggerFactory.getLogger(ChatController.class);

    private final AiChatService aiChatService;

    @Autowired
    public ChatController(AiChatService aiChatService) {
        this.aiChatService = aiChatService;
    }

    /**
     * 处理用户的聊天消息
     *
     * @param request 包含用户消息的请求体
     * @return AI 的响应
     */
    @PostMapping("/message")
    public ResponseEntity<Map<String, Object>> handleChatMessage(@RequestBody Map<String, String> request) {
        String userMessage = request.get("message");
        logger.info("收到聊天消息，长度: {} 字符", userMessage != null ? userMessage.length() : 0);

        Map<String, Object> response = new HashMap<>();

        try {
            // 验证输入
            if (userMessage == null || userMessage.trim().isEmpty()) {
                logger.warn("收到空的聊天消息");
                response.put("success", false);
                response.put("error", "消息内容不能为空");
                return ResponseEntity.badRequest().body(response);
            }

            // 检查消息长度
            if (userMessage.length() > 10000) {
                logger.warn("收到过长的聊天消息: {} 字符", userMessage.length());
                response.put("success", false);
                response.put("error", "消息内容过长，请限制在 10000 字符以内");
                return ResponseEntity.badRequest().body(response);
            }

            // 检查 AI 服务是否可用
            if (!aiChatService.isServiceAvailable()) {
                logger.error("AI 服务不可用");
                response.put("success", false);
                response.put("error", "AI 服务当前不可用，请稍后再试");
                return ResponseEntity.status(HttpStatus.SERVICE_UNAVAILABLE).body(response);
            }

            // 处理用户消息
            String aiResponse = null;
            int maxRetries = 1;
            int attempt = 0;

            while (attempt <= maxRetries) {
                try {
                    aiResponse = aiChatService.processUserMessage(userMessage.trim());
                    break; // 成功后跳出循环
                } catch (Exception e) {
                    attempt++;
                    if (attempt > maxRetries) {
                        // 最后一次失败，记录日志或返回默认提示
                        // logger.error("请求失败，已重试 {} 次", maxRetries, e);
                        aiResponse = "请求失败，请稍后再试。";
                    }
                }
            }

            response.put("success", true);
            response.put("message", aiResponse);
            response.put("timestamp", System.currentTimeMillis());

            logger.info("聊天消息处理成功，响应长度: {} 字符", aiResponse.length());
            return ResponseEntity.ok(response);

        } catch (Exception e) {
            logger.error("处理聊天消息时发生错误", e);
            response.put("success", false);
            response.put("error", "处理消息时发生错误: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
        }
    }

    /**
     * 获取 AI 服务状态
     *
     * @return 服务状态信息
     */
    @GetMapping("/status")
    public ResponseEntity<Map<String, Object>> getChatServiceStatus() {
        logger.debug("收到获取聊天服务状态的请求");

        Map<String, Object> status = new HashMap<>();

        try {
            boolean isAvailable = aiChatService.isServiceAvailable();
            String serviceStatus = aiChatService.getServiceStatus();

            status.put("available", isAvailable);
            status.put("status", serviceStatus);
            status.put("timestamp", System.currentTimeMillis());

            if (isAvailable) {
                status.put("message", "AI 聊天服务运行正常，可以开始对话");
            } else {
                status.put("message", "AI 聊天服务暂时不可用");
            }

            return ResponseEntity.ok(status);

        } catch (Exception e) {
            logger.error("获取聊天服务状态时发生错误", e);
            status.put("available", false);
            status.put("error", "获取服务状态失败: " + e.getMessage());
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(status);
        }
    }

    /**
     * 健康检查接口
     *
     * @return 服务健康状态
     */
    @GetMapping("/health")
    public ResponseEntity<Map<String, Object>> healthCheck() {
        Map<String, Object> health = new HashMap<>();
        health.put("status", "UP");
        health.put("service", "AI Chat Service");
        health.put("timestamp", System.currentTimeMillis());
        return ResponseEntity.ok(health);
    }

    /**
     * 获取使用帮助信息
     *
     * @return 使用帮助
     */
    @GetMapping("/help")
    public ResponseEntity<Map<String, Object>> getHelp() {
        Map<String, Object> help = new HashMap<>();

        help.put("title", "API 测试工具使用帮助");
        help.put("description", "这是一个基于 AI 的接口测试工具，支持对话式交互");

        Map<String, String> examples = new HashMap<>();
        examples.put("上传文档后查看", "显示所有文档");
        examples.put("设置认证", "设置固定参数 Authorization Bearer your-token-here");
        examples.put("测试接口", "测试 GET /api/users 接口");
        examples.put("删除文档", "卸载这个文档");
        examples.put("查看参数", "显示所有固定参数");

        help.put("examples", examples);

        Map<String, String> tips = new HashMap<>();
        tips.put("文档管理", "上传 OpenAPI/Swagger 文档后，可以通过对话方式管理和测试接口");
        tips.put("参数设置", "设置 API Key、Authorization 等固定参数，会自动添加到所有请求中");
        tips.put("智能测试", "AI 会根据文档内容推荐测试场景和最佳实践");
        tips.put("自然语言", "使用自然语言描述测试需求，AI 会理解并执行相应操作");

        help.put("tips", tips);
        help.put("timestamp", System.currentTimeMillis());

        return ResponseEntity.ok(help);
    }
}

